import { invoke } from '@tauri-apps/api/core';
class TauriClient {
  constructor(defaultTimeout = 5000) {
    this.defaultTimeout = defaultTimeout;
    this.pendingRequests = new Map();
  }

  /**
   * 调用 Rust 命令，支持超时控制
   * @param {string} command - 命令名称
   * @param {object} args - 命令参数
   * @param {number} timeout - 超时时间（毫秒），默认使用构造函数设置的值
   * @returns {Promise<*>} - 返回命令执行结果或错误
   */
  async invoke(command, args = {}, timeout = this.defaultTimeout) {
    const requestId = this.generateRequestId();
    const controller = new AbortController();
    const signal = controller.signal;

    // 记录请求
    this.trackRequest(requestId, controller);

    try {
      // 执行命令调用和超时竞争
      const result = await Promise.race([
        this.executeCommand(command, args, signal),
        this.createTimeoutPromise(timeout, requestId)
      ]);

      // 请求成功完成，清除跟踪
      this.clearRequest(requestId);
      return result;
    } catch (error) {
      // 请求失败，清除跟踪
      this.clearRequest(requestId);

      // 区分超时错误和其他错误
      if (error.name === 'TimeoutError') {
        throw new Error(`命令 "${command}" 执行超时（${timeout}ms）`);
      }

      throw error;
    }
  }

  /**
   * 实际执行 Tauri 命令
   */
  async executeCommand(command, args, signal) {
    // 使用 AbortSignal 支持请求取消（如果 Tauri 支持）
    return invoke(command, args, { signal });
  }

  /**
   * 创建超时 Promise
   */
  createTimeoutPromise(timeout, requestId) {
    return new Promise((_, reject) => {
      setTimeout(() => {
        // 超时后取消请求
        const controller = this.pendingRequests.get(requestId);
        if (controller) {
          controller.abort();
        }

        reject({ name: 'TimeoutError' });
      }, timeout);
    });
  }

  /**
   * 生成唯一请求 ID
   */
  generateRequestId() {
    return Math.random().toString(36).substring(2, 10);
  }

  /**
   * 跟踪请求
   */
  trackRequest(requestId, controller) {
    this.pendingRequests.set(requestId, controller);
  }

  /**
   * 清除请求跟踪
   */
  clearRequest(requestId) {
    this.pendingRequests.delete(requestId);
  }

  /**
   * 获取当前所有未完成的请求
   */
  getPendingRequests() {
    return Array.from(this.pendingRequests.keys());
  }

  /**
   * 取消所有未完成的请求
   */
  cancelAllRequests() {
    this.pendingRequests.forEach(controller => controller.abort());
    this.pendingRequests.clear();
  }
}

// 创建单例实例
export const tauriClient = new TauriClient(5000);